//! # 组件配置模块
//! 
//! 定义RustCloud框架各组件的配置结构。

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use rustcloud_core::config_builder::{RetryConfig, TimeoutConfig, ConfigFactory};
use crate::config::{
    RegistryConfig, LoadBalancerConfig, CircuitBreakerConfig, 
    ProxyConfig, GatewayConfig, ConsistentHashConfig,
    HealthCheckConfig, AuthConfig, CacheConfig, RetryConfig, TimeoutConfig,
    MiddlewareConfig, RouteConfig, AuthMiddlewareConfig, RateLimitConfig, CorsConfig,
    JwtConfig
};

/// 组件配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComponentConfig {
    /// 服务注册中心配置
    pub registry: RegistryConfig,
    
    /// 负载均衡配置
    pub load_balancer: LoadBalancerConfig,
    
    /// 熔断器配置
    pub circuit_breaker: CircuitBreakerConfig,
    
    /// 代理配置
    pub proxy: ProxyConfig,
    
    /// 网关配置
    pub gateway: Option<GatewayConfig>,
    
    /// 🆕 新增：配置广播功能配置
    #[serde(default)]
    pub config_broadcast: ConfigBroadcastConfig,
}

impl Default for ComponentConfig {
    fn default() -> Self {
        Self {
            registry: RegistryConfig::default(),
            load_balancer: LoadBalancerConfig::default(),
            circuit_breaker: CircuitBreakerConfig::default(),
            proxy: ProxyConfig::default(),
            gateway: None,
            config_broadcast: ConfigBroadcastConfig::default(),
        }
    }
}

/// 注册中心配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RegistryConfig {
    /// 注册中心类型（nacos、consul、eureka、etcd）
    pub registry_type: String,
    
    /// 注册中心地址
    pub endpoints: Vec<String>,
    
    /// 命名空间
    pub namespace: Option<String>,
    
    /// 服务分组
    pub group: Option<String>,
    
    /// 认证配置
    pub auth: Option<AuthConfig>,
    
    /// 健康检查配置
    pub health_check: HealthCheckConfig,
    
    /// 额外配置
    pub extra: HashMap<String, serde_json::Value>,
}

impl Default for RegistryConfig {
    fn default() -> Self {
        Self {
            registry_type: "memory".to_string(),
            endpoints: vec!["127.0.0.1:8848".to_string()],
            namespace: None,
            group: None,
            auth: None,
            health_check: HealthCheckConfig::default(),
            extra: HashMap::new(),
        }
    }
}

/// 负载均衡配置（重复定义！）
/// WARNING: 这是重复定义，应该使用专门模块中的配置
/// TODO: 使用 rustcloud-loadbalancer 模块中的相关配置
#[derive(Debug, Clone, Serialize, Deserialize)]
#[deprecated(note = "请使用 rustcloud-loadbalancer 模块中的配置")]
pub struct LoadBalancerConfig {
    /// 负载均衡策略（round_robin、random、weighted_round_robin、least_connections、consistent_hash）
    pub strategy: String,
    
    /// 权重配置
    pub weights: HashMap<String, u32>,
    
    /// 一致性哈希配置
    pub consistent_hash: Option<ConsistentHashConfig>,
    
    /// 健康检查相关的负载均衡配置
    pub health_based: bool,
}

impl Default for LoadBalancerConfig {
    fn default() -> Self {
        Self {
            strategy: "round_robin".to_string(),
            weights: HashMap::new(),
            consistent_hash: None,
            health_based: true,
        }
    }
}

/// 一致性哈希配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConsistentHashConfig {
    /// 虚拟节点数量
    pub virtual_nodes: u32,
    
    /// 哈希函数类型
    pub hash_function: String,
}

impl Default for ConsistentHashConfig {
    fn default() -> Self {
        Self {
            virtual_nodes: 160,
            hash_function: "fnv".to_string(),
        }
    }
}

/// 熔断器配置（重复定义！）
/// WARNING: 这是重复定义，应该使用专门模块中的配置
/// TODO: 使用 rustcloud-circuit-breaker::CircuitBreakerConfig
#[derive(Debug, Clone, Serialize, Deserialize)]
#[deprecated(note = "请使用 rustcloud-circuit-breaker 模块中的 CircuitBreakerConfig")]
pub struct CircuitBreakerConfig {
    /// 是否启用熔断器
    pub enabled: bool,
    
    /// 失败阈值
    pub failure_threshold: u32,
    
    /// 成功阈值
    pub success_threshold: u32,
    
    /// 超时时间（毫秒）
    pub timeout_ms: u64,
    
    /// 最大并发数
    pub max_concurrent_requests: u32,
    
    /// 请求量阈值
    pub request_volume_threshold: u32,
    
    /// 错误百分比阈值
    pub error_percentage_threshold: f64,
    
    /// 睡眠窗口（毫秒）
    pub sleep_window_ms: u64,
}

impl Default for CircuitBreakerConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            failure_threshold: 5,
            success_threshold: 3,
            timeout_ms: 5000,
            max_concurrent_requests: 100,
            request_volume_threshold: 20,
            error_percentage_threshold: 50.0,
            sleep_window_ms: 5000,
        }
    }
}

/// 代理配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProxyConfig {
    /// 是否启用代理
    pub enabled: bool,
    
    /// 缓存配置
    pub cache: CacheConfig,
    
    /// 重试配置（使用统一的重试配置）
    pub retry: RetryConfig,
    
    /// 超时配置（使用统一的超时配置）
    pub timeout: TimeoutConfig,
}

impl Default for ProxyConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            cache: CacheConfig::default(),
            // 使用统一的配置工厂创建标准配置
            retry: ConfigFactory::create_fast_retry(),
            timeout: TimeoutConfig::builder()
                .connect_timeout(std::time::Duration::from_secs(30))
                .request_timeout(std::time::Duration::from_secs(30))
                .idle_timeout(std::time::Duration::from_secs(60))
                .build()
                .expect("Failed to build timeout config"),
        }
    }
}

/// 缓存配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CacheConfig {
    /// 是否启用缓存
    pub enabled: bool,
    
    /// 缓存策略
    pub strategy: String,
    
    /// TTL（秒）
    pub ttl_seconds: u64,
    
    /// 最大条目数
    pub max_entries: usize,
}

impl Default for CacheConfig {
    fn default() -> Self {
        Self {
            enabled: false,
            strategy: "lru".to_string(),
            ttl_seconds: 300,
            max_entries: 1000,
        }
    }
}

/// 重试配置（重新导出统一配置，保持向后兼容）
pub use rustcloud_core::config_builder::RetryConfig as UnifiedRetryConfig;

/// 为了保持向后兼容，提供原有的 RetryConfig 类型别名
pub type RetryConfig = UnifiedRetryConfig;

/// 超时配置（重新导出统一配置，保持向后兼容）
pub use rustcloud_core::config_builder::TimeoutConfig as UnifiedTimeoutConfig;

/// 为了保持向后兼容，提供原有的 TimeoutConfig 类型别名
pub type TimeoutConfig = UnifiedTimeoutConfig;

/// 网关配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GatewayConfig {
    /// 是否启用网关
    pub enabled: bool,
    
    /// 监听端口
    pub port: u16,
    
    /// 路由配置
    pub routes: Vec<RouteConfig>,
    
    /// 中间件配置
    pub middleware: MiddlewareConfig,
}

/// 路由配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RouteConfig {
    /// 路径模式
    pub path: String,
    
    /// 目标服务
    pub service: String,
    
    /// HTTP方法
    pub methods: Vec<String>,
    
    /// 权重
    pub weight: Option<u32>,
}

/// 中间件配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MiddlewareConfig {
    /// 认证中间件
    pub auth: Option<AuthMiddlewareConfig>,
    
    /// 限流中间件
    pub rate_limit: Option<RateLimitConfig>,
    
    /// CORS配置
    pub cors: Option<CorsConfig>,
}

/// 认证中间件配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuthMiddlewareConfig {
    /// 认证类型
    pub auth_type: String,
    
    /// JWT配置
    pub jwt: Option<JwtConfig>,
}

/// JWT配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct JwtConfig {
    /// 密钥
    pub secret: String,
    
    /// 过期时间（秒）
    pub expiration_seconds: u64,
}

/// 限流配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RateLimitConfig {
    /// 每秒请求数
    pub requests_per_second: u32,
    
    /// 突发容量
    pub burst_capacity: u32,
}

/// CORS配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CorsConfig {
    /// 允许的来源
    pub allowed_origins: Vec<String>,
    
    /// 允许的方法
    pub allowed_methods: Vec<String>,
    
    /// 允许的头部
    pub allowed_headers: Vec<String>,
}

/// 🆕 新增：配置广播功能配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConfigBroadcastConfig {
    /// 是否启用配置广播功能
    pub enabled: bool,
    
    /// 消息总线类型（memory、redis、kafka、rabbitmq）
    pub message_bus_type: String,
    
    /// 消息总线连接配置
    pub connection_config: HashMap<String, serde_json::Value>,
    
    /// 广播主题前缀
    pub topic_prefix: String,
    
    /// 服务名称（用于标识发送者）
    pub service_name: Option<String>,
    
    /// 关注的应用列表（为空表示关注所有应用）
    pub interested_applications: Vec<String>,
    
    /// 配置变更监听器配置
    pub listeners: Vec<ConfigBroadcastListenerConfig>,
    
    /// 自动重启配置
    pub auto_restart: AutoRestartConfig,
}

impl Default for ConfigBroadcastConfig {
    fn default() -> Self {
        Self {
            enabled: false, // 默认禁用，用户手动启用
            message_bus_type: "memory".to_string(),
            connection_config: HashMap::new(),
            topic_prefix: "config.broadcast".to_string(),
            service_name: None, // 将使用 service.name
            interested_applications: Vec::new(), // 空表示关注所有
            listeners: Vec::new(),
            auto_restart: AutoRestartConfig::default(),
        }
    }
}

/// 配置变更监听器配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConfigBroadcastListenerConfig {
    /// 监听器名称
    pub name: String,
    
    /// 监听器类型（logging、restart、custom）
    pub listener_type: String,
    
    /// 关注的应用列表
    pub interested_applications: Vec<String>,
    
    /// 监听器参数
    pub config: HashMap<String, serde_json::Value>,
}

/// 自动重启配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AutoRestartConfig {
    /// 是否启用自动重启
    pub enabled: bool,
    
    /// 重启延迟时间（秒）
    pub restart_delay_seconds: u64,
    
    /// 最大重启次数
    pub max_restart_attempts: u32,
    
    /// 重启间隔时间（秒）
    pub restart_interval_seconds: u64,
}

impl Default for AutoRestartConfig {
    fn default() -> Self {
        Self {
            enabled: false,
            restart_delay_seconds: 30,
            max_restart_attempts: 3,
            restart_interval_seconds: 300, // 5分钟
        }
    }
}